% future/HTMtableRCU.tex

\begin{table*}[p]
\begin{center}
\small
\raggedright
\begin{tabular}{p{1.0in}||c|p{2.0in}||c|p{2.0in}}
& \multicolumn{2}{c||}{Locking with RCU or Hazard Pointers} & \multicolumn{2}{c}{Hardware Transactional Memory} \\
\hline
\hline
Basic Idea
	& \multicolumn{2}{p{2.2in}||}{
	  Allow only one thread at a time to access a given set of objects.}
		& \multicolumn{2}{p{2.2in}}{
		  Cause a given operation over a set of objects to execute
		  atomically.} \\
\hline
\hline
Scope
	& $+$
	& Handles all operations.
		& $+$
		& Handles idempotent operations. \\
\cline{4-5}
	& &
		& $-$
		& Non-idempotent operations force fallback (typically
		  to locking). \\
\hline
Composability
	& $+$
	& Readers limited only by grace-period-wait operations.
		& $\Downarrow$
		& Limited by non-idempotent operations, transaction size,
		  and deadlock. \\
\cline{2-3}
	& $-$
	& Updaters limited by deadlock.  Readers reduce deadlock.
		&
		& (Assuming lock-based fallback code.) \\
\hline
Scalability \& Performance
	& $-$
	& Data must be partitionable to avoid lock contention among
	  updaters.
		& $-$
		& Data must be partionable to avoid conflicts. \\
\cline{2-3}
	& $+$
	& Partitioning not needed for readers.
		&
		& \\
\cline{2-5}
	& $\Downarrow$
	& Partioning for updaters must typically be fixed at design time.
		& $+$
		& Dynamic adjustment of partitioning carried out
		  automatically down to cacheline boundaries. \\
\cline{2-5}
	& $+$
	& Partitioning not needed for readers.
		& $-$
		& Partitioning required for fallbacks (less important
		  for rare fallbacks). \\
\cline{2-5}
	& $\Downarrow$
	& Updater locking primitives typically result in expensive cache
	  misses and memory-barrier instructions.
		& $-$
		& Transactions begin/end instructions typically do not
		  result in cache misses, but do have memory-ordering
		  consequences. \\
\cline{2-5}
	& $+$
	& Update-side contention effects are focused on acquisition and
	  release, so that the critical section runs at full speed.
		& $-$
		& Contention aborts conflicting transactions, even
		  if they have been running for a long time. \\
\cline{2-3}
	& $+$
	& Readers do not contend with updaters or with each other.
		&
		& \\
\cline{2-5}
	& $+$
	& Read-side primitives are typically wait-free with low
	  overhead.  (Lock-free for hazard pointers.)
		& $-$
		& Read-only transactions subject to conflicts and rollbacks.
		  No forward-progress guarantees other than those supplied
		  by fallback code. \\
\cline{2-5}
	& $+$
	& Privatization operations are simple, intuitive, performant,
	  and scalable when data is visible only to updaters.
		& $-$
		& Privatized data contributes to transaction size. \\
\cline{2-3}
	& $-$
	& Privitization operations are expensive (though still intuitive
	  and scalable) for reader-visible data.
		&
		& \\
\hline
Hardware Support
	& $+$
	& Commodity hardware suffices.
		& $-$
		& New hardware required (and is starting to become
		  available). \\
\cline{2-5}
	& $+$
	& Performance is insensitive to cache-geometry details.
		& $-$
		& Performance depends critically on cache geometry. \\
\hline
Software Support
	& $+$
	& APIs exist, large body of code and experience, debuggers operate
	  naturally.
		& $-$
		& APIs emerging, little experience outside of DBMS,
		  breakpoints mid-transaction can be problematic. \\
\hline
Interaction With Other Mechanisms
	& $+$
	& Long experience of successful interaction.
		& $\Downarrow$
		& Just beginning investigation of interaction. \\
\hline
Practical Apps
	& $+$
	& Yes.
		& $+$
		& Yes. \\
\hline
Wide Applicability
	& $+$
	& Yes.
		& $-$
		& Jury still out, but likely to win significant use. \\
\end{tabular}
\end{center}
\caption{Comparison of Locking (Augmented by RCU or Hazard Pointers) and HTM (``+'' is Advantage, ``-'' is Disadvantage, ``$\Downarrow$'' is Strong Disadvantage)}
\label{tab:future:Comparison of Locking (Augmented by RCU or Hazard Pointers) and HTM}
\end{table*}
